//stc8H2K08U  ̵
#include <COMM/STC8H.h>					 //MCUͷļ
#include "intrins.h"					 //nopָͷļ 
#include "stdio.h"/* Ҫڳʹô˴,ڳעʹSTCϼ            */
typedef     unsigned char   u8;
typedef     unsigned int    u16;
typedef     unsigned long   u32;
								typedef unsigned char	uint8;//庯
								typedef unsigned int	uint16;//庯
								typedef unsigned long	uint32; //庯
#define MAIN_Fosc        22118400UL											 
#define Timer0_Reload   (65536UL -(MAIN_Fosc / 1))       //Timer 0 жƵ, 1000/ ĳ1һ




//STC8h շ1


#define     Baudrate1           115200L
#define     UART1_BUF_LENGTH    64


u8  TX1_Cnt;    //ͼ
u8  RX1_Cnt;    //ռ
bit B_TX1_Busy; //æ־

u8  xdata RX1_Buffer[UART1_BUF_LENGTH]; //ջ


void UART1_config(u8 brt);   // ѡ, 2: ʹTimer2, ֵ: ʹTimer1.
void PrintString1(u8 *puts);
void UART_SendNumber2(float num);
//STC8h շ1







unsigned int fushu=0;//ʾֵΪʶ
unsigned int xsbl;
/*ADC*/
//ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ//
#define adc_NUM_SAMPLES 5
u16 adc_average;
float wendu;
uint16 adc_i=0,adc_j,adc_temp;      
uint16 xdata adc_samples[adc_NUM_SAMPLES];
// ADCݻ
// ƽֵ
float adc_calculate_average()
{
    float adc_sum = 0;
    
    // вݽ
    for(adc_i = 0; adc_i < adc_NUM_SAMPLES; adc_i++)
    {
        adc_sum += adc_samples[adc_i];
    }
    
    // ƽֵ
    return adc_sum / adc_NUM_SAMPLES;
}
//ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ////ADCⲿ//
/*************	س	**************/

#define ADC_START	(1<<6)	/* Զ0 */
#define ADC_FLAG	(1<<5)	/* 0 */

#define	ADC_SPEED	15		/* 0~15, ADCתʱ(CPUʱ) = (n+1)*32  ADCCFG */
#define	RES_FMT		(1<<5)	/* ADCʽ 0: , ADC_RES: D11 D10 D9 D8 D7 D6 D5 D4, ADC_RESL: D3 D2 D1 D0 0 0 0 0 */
							/* ADCCFG     1: Ҷ, ADC_RES: 0 0 0 0 D11 D10 D9 D8, ADC_RESL: D7 D6 D5 D4 D3 D2 D1 D0 */

#define BUBBLE_SORT     //ʹðȥֵֵмƽֵҪĻδУ

#define SUM_LENGTH	16	/* ƽֵ ֵ16ҪĻɽֵΪ 1 */

/*************	ر	**************/


/*************	غ	**************/

u16		Get_ADC12bitResult(u8 channel);
void	delay_ms(u8 ms);
void	ADC_convert(u8 chn);	//chn=0~7ӦP1.0~P1.7, chn=8~14ӦP0.0~P0.6, chn=15ӦBandGapѹ
/*ADC*/





/*************  س    **************/
//   0     1  	2		3			4		5			6		7			8		9			10	11		12	12		14	15				 
// 	16    17  	18	19	20		21		22	23		24	25		26		27 28   29   30   31	

//P20-27 
unsigned char code t_display[]={                       //P2
//   0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
    0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71,
//   0     1  	2		3			4		5			6		7			8		9		0x0A 0x0B	0x0c 0x0d	0x0e 0x0f	
//  black  -   H    J    K    L    N    o   P    U     t    G    Q    r   M    y
    0x00,0x40,0x76,0x1E,0x70,0x38,0x37,0x5C,0x73,0x3E,0x78,0x3d,0x67,0x50,0x37,0x6e,
//	0x10 0x11  0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1A 0x1B 0x1C 0x1D 0x1E 0x1F
    0xBF,0x86,0xDB,0xCF,0xE6,0xED,0xFD,0x87,0xFF,0xEF,0x46};    //0. 1. 2. 3. 4. 5. 6. 7. 8. 9. -1
//  0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2A
unsigned char code T_COM[]={0x01,0x02,0x04,0x08};      //λP04λ


unsigned char  LED8[4];        //ʾ
unsigned char  display_index=0;  //ʾλ
bit B_1ms;          //1ms־

unsigned int msecond;   //



/********************** ʾʱӺ ************************/
void displayled(void)
{
    //ұһλ     
		LED8[0] =0x10;  
    LED8[1] =0x29;
    LED8[2] =3;
    LED8[3] =4;
		//ұλ
}


float aaa=2495555; //
/********************  **************************/
void main(void)
{
  
/*
    WTST = 0;  //óָʱֵΪ0ɽCPUִָٶΪ
    EAXFR = 1; //չĴ(XFR)ʹ
    CKCON = 0; //߷XRAMٶ
*/
P_SW2 |= 0x80;  //չĴ(XFR)ʹ  //stc8h2
//LEDţSTCֱģ鶨ʱ0ã
//׼˫ʾȽºҲʡ
    P0M0 = 0x00; P0M1 = 0x00; 
    P2M0 = 0x00; P2M1 = 0x00; 
    P1M0 &= ~0x20; P1M1 |= 0x20;  //ɼͨ16 adc6ø
    P1IE &= ~0x40;              	 //ɼͨ16 adc6


//LED
//ʱ0
		AUXR |= 0x80;			//ʱʱ1Tģʽ
		TMOD &= 0xF0;			//öʱģʽ
    TH0 = (unsigned char)(Timer0_Reload / 256);
    TL0 = (unsigned char)(Timer0_Reload % 256);
    ET0 = 1;    //Timer0 interrupt enable
    TR0 = 1;    //Tiner0 run
    EA = 1;     //ж  
	
	
	//STC8h շ2
    UART1_config(1);    // ѡ, 2: ʹTimer2, ֵ: ʹTimer1.
    EA = 1; //ж

    PrintString1("STC8H8K64U UART1 Test Programme!\r\n");  //UART1һַ
//STC8h շ2
	
//ʱ0ãSTCֱģ鶨ʱ0ã

//ȫԹܣSTCֱģϵԣ
		LED8[0] =0x28;
    LED8[1] =0x28;
    LED8[2] =0x28;
    LED8[3] =0x28;
//ȫԹܣSTCֱģϵԣ



	//ADCģԴ򿪺ȴ1msMCUڲADCԴȶٽADת
	ADC_CONTR = 0x80 + 0;	//ADC on + channel (ע⣺STC8AϵоƬADCģԴͬʱchannelӦIOڻᱻǿΪ룬رֹ)
	ADCCFG = RES_FMT + ADC_SPEED;

	ADCTIM = 0x3f;  //ͨѡʱ䡢ʱ䡢ʱ

#if 1    //STC8H4KSTC8H8KϵоƬ֧չĴӲԶȡƽֵ
//	ADCEXCFG = 0x00;    //ת1βȡƽֵ
	ADCEXCFG = 0x04;    //ת2βȡƽֵ
//	ADCEXCFG = 0x05;    //ת4βȡƽֵ
//	ADCEXCFG = 0x06;    //ת8βȡƽֵ
//	ADCEXCFG = 0x07;    //ת16βȡƽֵ
#endif




    while(1)
    { 
			
			
			
			
			
			
// ȡֵ		
			/*
    for(adc_i = 0; adc_i < adc_NUM_SAMPLES;adc_i++)    
			{	
			adc_samples[adc_i] = Get_ADC12bitResult(3);     				
			} 
			*/
// ƽֵ
//adc_average = adc_calculate_average()*2525000/4096;
//ADC		
			adc_average=Get_ADC12bitResult(6);
//adc_average=adc_average-7000;
//ѹת¶	
//adc_average=838000;	
			
if (adc_average<509500)
{
wendu=400;

}
//0-500
if (adc_average>=509500 && adc_average<559900)
{	
wendu=400-(adc_average-509500)/504;
}

if (adc_average>=559900 && adc_average<609900)
{
wendu=300-(adc_average-559900)/500;
}

if (adc_average>=609900 && adc_average<659800)
{	
wendu=200-(adc_average-609900)/499;
}

if (adc_average>=659800 && adc_average<709100)
{	
wendu=100-(adc_average-659800)/493;
}

if (adc_average<709100)
{fushu=1;}
else
{fushu=0;}
	

if (adc_average>=709100 && adc_average<757800)
{
wendu=(adc_average-709100)/487;
}

if (adc_average>=757800 && adc_average<806500)
{
wendu=100+(adc_average-757800)/487;
}



if (adc_average>=806500 && adc_average<830740)
{
wendu=200+(adc_average-806500)/484.8;
}



if (adc_average>=830740 && adc_average<854850)
{
wendu=250+(adc_average-830740)/484.2;
}

if (adc_average>=854850 && adc_average<902800)
{
wendu=300+(adc_average-854850)/479.5;
}


if (adc_average>=902800 && adc_average<950370)
{
wendu=400+(adc_average-902800)/475.7;
}

if (adc_average>=950370 && adc_average<997670)
{
wendu=500+(adc_average-950370)/473;
}

if (adc_average>=997670 && adc_average<1044640)
{
wendu=600+(adc_average-997670)/469.7;
}

if (adc_average>=1044640 && adc_average<1091220)
{
wendu=700+(adc_average-1044640)/465.8;
}

if (adc_average>=1091220 && adc_average<1137400)
{
wendu=800+(adc_average-1091220)/461.8;
}

if (adc_average>=1137400 && adc_average<1183320)
{
wendu=900+(adc_average-1137400)/459.2;
}

if (adc_average>=1183320 && adc_average<1408300)
{
wendu=1000+(adc_average-1183320)/449.96;
}

if (adc_average>=1408300 && adc_average<1625500)
{
wendu=1500+(adc_average-1408300)/543;
}

if (adc_average>=1625500 && adc_average<1835350)
{
wendu=2000+(adc_average-1625500)/524.6;
}

if (adc_average>=1835350 && adc_average<2038300)
{
wendu=2500+(adc_average-1835350)/507.37;
}

if (adc_average>=2038300 && adc_average<2234440)
{
wendu=3000+(adc_average-2038300)/490.35;
}

if (adc_average>=2234440 && adc_average<2424000)
{
wendu=3500+(adc_average-2234440)/473.9;
}



if (adc_average>=2424000)
{
wendu=4000;
}




xsbl=(int)wendu;


//ѹת¶
			
			
			
			//STCֱģ飩
        if(B_1ms)   //1ms
        {
            B_1ms = 0;
					        if(++msecond >= 1000)   //1뵽
            {
                msecond = 0;
              //  displayled();
							//ʾܸ

LED8[0]=xsbl % 10;	
LED8[1]=xsbl % 100/10;
LED8[2]=xsbl % 1000/100;
LED8[3]=xsbl % 10000/1000;
							UART_SendNumber2(adc_average);//
							
							
            }
               
        }
			//STCֱģ飩
    }
}
//һDisplayScanܵɨʾöʱ0ʵ1msлһεĲˢʾܣSTCֱģ飩
/********************** ʾɨ躯 ************************/
void DisplayScan(void)
{   
	P0 = ~T_COM[3-display_index];							//Ҫȡ			//8λ74
	P2 = t_display[LED8[display_index]];						//ȡ					
    if(++display_index >= 4)    display_index = 0;  //8λ0          //8λ4λ
}










/*ADCɼ*/
//========================================================================
// : u16	Get_ADC12bitResult(u8 channel))	//channel = 0~15
// : ѯһADC.
// : channel: ѡҪתADC, 0~15.
// : 12λADC.
// 汾: V1.0, 2016-4-28
//========================================================================
u16	Get_ADC12bitResult(u8 channel)	//channel = 0~15
{
	ADC_RES = 0;
	ADC_RESL = 0;

	ADC_CONTR = 0x80 | ADC_START | channel; 
	NOP(10);			//
	while((ADC_CONTR & ADC_FLAG) == 0)	;	//ȴADC
	ADC_CONTR &= ~ADC_FLAG;
	return	((u16)ADC_RES * 256 + (u16)ADC_RESL);
}

/***********************************
ѯʽһADC, chnΪͨ, chn=0~7ӦP1.0~P1.7, chn=8~14ӦP0.0~P0.6, chn=15ӦBandGapѹ.
***********************************/

/*ADCɼ*/










//STC8h շ3
//========================================================================
// : 1ַ
//========================================================================
void PrintString1(u8 *puts) //һַ
{
    for (; *puts != 0;  puts++)     //ֹͣ0
    {
        SBUF = *puts;
        B_TX1_Busy = 1;
        while(B_TX1_Busy);
    }
}

//========================================================================
// : void UART_SendNumber(int num)
// : 1ַ
// : num		ֵ
// : none.
// 汾: VER1.0
// : 2014-11-28
// ע: #include "stdio.h" //Ҫͷļ
//========================================================================

void UART_SendNumber2(float num) {
    char buffer[30];
    sprintf(buffer, "%1.0f", num);  // תΪַ
    PrintString1(buffer);     // ַ
}
//========================================================================
// : SetTimer2Baudraye(u16 dat)
// : Timer2ʷ
//========================================================================
void SetTimer2Baudraye(u16 dat)  // ѡ, 2: ʹTimer2, ֵ: ʹTimer1.
{
    AUXR &= ~(1<<4);    //Timer stop
    AUXR &= ~(1<<3);    //Timer2 set As Timer
    AUXR |=  (1<<2);    //Timer2 set as 1T mode
    T2H = dat / 256;
    T2L = dat % 256;
    IE2  &= ~(1<<2);    //ֹж
    AUXR |=  (1<<4);    //Timer run enable
}
//========================================================================
// : void UART1_config(u8 brt)
// : UART1ʼ
// : brt: ѡ, 2: ʹTimer2, ֵ: ʹTimer1.
//========================================================================
void UART1_config(u8 brt)    // ѡ, 2: ʹTimer2, ֵ: ʹTimer1.
{
    /*********** ʹöʱ2 *****************/
    if(brt == 2)
    {
        AUXR |= 0x01;       //S1 BRT Use Timer2;
        SetTimer2Baudraye(65536UL - (MAIN_Fosc / 4) / Baudrate1);
    }

    /*********** ʹöʱ1 *****************/
    else
    {
        TR1 = 0;
        AUXR &= ~0x01;      //S1 BRT Use Timer1;
        AUXR |=  (1<<6);    //Timer1 set as 1T mode
        TMOD &= ~(1<<6);    //Timer1 set As Timer
        TMOD &= ~0x30;      //Timer1_16bitAutoReload;
        TH1 = (u8)((65536UL - (MAIN_Fosc / 4) / Baudrate1) / 256);
        TL1 = (u8)((65536UL - (MAIN_Fosc / 4) / Baudrate1) % 256);
        ET1 = 0;    //ֹж
        INTCLKO &= ~0x02;   //ʱ
        TR1  = 1;
    }
    /*************************************************/

    SCON = (SCON & 0x3f) | 0x40;    //UART1ģʽ, 0x00: ͬλ, 0x40: 8λ,ɱ䲨, 0x80: 9λ,̶, 0xc0: 9λ,ɱ䲨
//  PS  = 1;    //ȼж
    ES  = 1;    //ж
    REN = 1;    //
    P_SW1 &= 0x3f;
    P_SW1 |= 0x00;      //UART1 switch to, 0x00: P3.0 P3.1, 0x40: P3.6 P3.7, 0x80: P1.6 P1.7, 0xC0: P4.3 P4.4
//  PCON2 |=  (1<<4);   //ڲ·RXDTXD, м, ENABLE,DISABLE

    B_TX1_Busy = 0;
    TX1_Cnt = 0;
    RX1_Cnt = 0;
}

//========================================================================
// : void UART1_int (void) interrupt UART1_VECTOR
// : UART1жϺ
//========================================================================
void UART1_int (void) interrupt 4
{
    if(RI)
    {
        RI = 0;
        RX1_Buffer[RX1_Cnt] = SBUF;
        if(++RX1_Cnt >= UART1_BUF_LENGTH)   RX1_Cnt = 0;    //
    }

    if(TI)
    {
        TI = 0;
        B_TX1_Busy = 0;
    }
}
//STC8h շ3









/********************** Timer0 1msжϺ ************************/
void Timer0_Isr(void) interrupt 1
{
    DisplayScan();  //1msɨʾһλ
    B_1ms = 1;      //1ms־

}
//һDisplayScanܵɨʾöʱ0ʵ1msлһεĲˢʾܣSTCֱģ飩